import { defineStore } from 'pinia'
import { ref, computed } from 'vue'
import request from '@/utils/http'
import { usePermissionStore } from './permission'
import userApi from '@/api/user.js'
import { Message } from '@arco-design/web-vue'
import axios from 'axios'

// 定义用户store
export const useUserStore = defineStore('user', () => {
  // 状态
  const token = ref(localStorage.getItem('wms_token') || '')
  const userInfo = ref(JSON.parse(localStorage.getItem('wms_user_info') || '{}'))
  const roles = ref(JSON.parse(localStorage.getItem('wms_roles') || '[]'))

  // 计算属性
  const isLoggedIn = computed(() => !!token.value)
  const username = computed(() => userInfo.value?.username || '')
  const nickname = computed(() => userInfo.value?.name || '')
  const avatar = computed(() => {
    // 直接返回原始头像路径，由UserAvatar组件处理
    let avatarPath = userInfo.value?.avatar || '';
    
    // 检查并移除时间戳参数（如果有）
    if (avatarPath.includes('?')) {
      avatarPath = avatarPath.substring(0, avatarPath.indexOf('?'));
    }
    
    // 移除可能存在的/api/v1前缀
    if (avatarPath.includes('/api/v1')) {
      avatarPath = avatarPath.replace('/api/v1', '');
    }
    
    // 确保路径以/开头
    if (avatarPath && !avatarPath.startsWith('/')) {
      avatarPath = '/' + avatarPath;
    }
    
    return avatarPath;
  })
  const baseURL = computed(() => import.meta.env.VITE_API_BASE_URL || 'http://localhost:3000')
  
  // 设置用户信息
  function setUserInfo(info) {
    userInfo.value = info
    localStorage.setItem('wms_user_info', JSON.stringify(info))
  }
  
  // 设置token
  function setToken(newToken) {
    token.value = newToken
    localStorage.setItem('wms_token', newToken)
  }
  
  // 登录操作
  async function loginAction(credentials) {
    try {
      const response = await userApi.login(credentials);

      // 适配后端实际返回格式
      if (response && (response.code === 200 || response.code === 0) && response.data) {
        // 获取token，保证不包含Bearer前缀
        let userToken = response.data.token;
        
        if (!userToken) {
          return false;
        }
        
        if (userToken.startsWith('Bearer ')) {
          userToken = userToken.substring(7);
        }
        
        // 保存token到state和localStorage
        token.value = userToken;
        localStorage.setItem('wms_token', userToken);
        
        // 保存用户基本信息
        const userData = {
          id: response.data.user_id,
          username: response.data.username,
          nickname: response.data.nickname || response.data.username,
          avatar: processAvatarUrl(response.data.avatar || ''),
          role_id: response.data.role_id
        };
        
        // 保存角色信息 - 根据role_id判断角色
        const roleId = parseInt(response.data.role_id);
        
        // 明确根据role_id设置角色
        if (roleId === 1) {
          roles.value = ['admin'];
        } else {
          roles.value = ['employee'];
        }
        
        localStorage.setItem('wms_roles', JSON.stringify(roles.value));
        
        // 保存用户信息到state和localStorage
        userInfo.value = userData;
        localStorage.setItem('wms_user_info', JSON.stringify(userData));
        
        return true;
      } else {
        // 登录失败，处理错误消息
        const errorMsg = response.message || response.msg || '登录失败';
        return false;
      }
    } catch (error) {
      return false;
    }
  }

  async function getUserInfo(forceRefresh = false) {
    try {
      // 检查token是否存在，如果不存在则返回空对象
      if (!token.value) {
        clearUserData(); // 清除可能存在的旧数据
        return {};
      }
      
      // 如果不是强制刷新且已有缓存数据，则直接返回缓存数据
      if (!forceRefresh && Object.keys(userInfo.value).length > 0) {
        return userInfo.value;
      }
      
      const response = await userApi.getUserInfo();
      
      if (response && (response.code === 200 || response.code === 0) && response.data) {
        // 保存用户信息
        const userData = {...response.data};
        
        // 处理头像URL格式
        userData.avatar = processAvatarUrl(userData.avatar);
        
        userInfo.value = userData;
        
        // 根据角色ID明确设置角色
        const roleId = parseInt(userData.role_id);
        
        if (roleId === 1) {
          roles.value = ['admin'];
        } else {
          roles.value = ['employee'];
        }
        
        localStorage.setItem('wms_roles', JSON.stringify(roles.value));
        localStorage.setItem('wms_user_info', JSON.stringify(userInfo.value));
        
        return userData;
      } else {
        return userInfo.value; // 使用已有数据
      }
    } catch (error) {
      // 如果是401错误，则清除用户数据
      if (error.response && error.response.status === 401) {
        clearUserData();
      }
      
      return {}; // 出错时返回空对象
    }
  }

  // 退出登录
  async function logout() {
    try {
      // 清除本地状态 - 先清除，确保状态被清除
      clearUserData();
      
      // 重置路由
      try {
        const permissionStore = usePermissionStore();
        permissionStore.resetRoutes();
      } catch (e) {
        // 静默处理路由重置错误
      }
      
      // 在清除状态后再调用登出API - 静默处理任何错误
      try {
        await userApi.logout();
      } catch (error) {
        // 静默处理API错误
      }
      
      // 立即跳转到登录页面
      setTimeout(() => {
        window.location.href = '/login';
      }, 100);
      
      // 添加返回值，表示登出成功
      return true;
    } catch (error) {
      // 确保状态被清除
      clearUserData();
      return false;
    }
  }

  // 修改密码
  async function updatePassword(passwordData) {
    try {
      const response = await userApi.changePassword(passwordData);
      
      // 请求成功的情况（返回码为200或0）
      if (response && (response.code === 200 || response.code === 0)) {
        return {
          success: true,
          message: '密码修改成功'
        };
      }
      
      // 请求返回但包含错误信息
      return {
        success: false,
        message: response.message || '修改密码失败，请检查输入'
      };
    } catch (error) {
      // 请求过程中出现异常
      return {
        success: false,
        message: error.message || '修改密码失败，请稍后重试'
      };
    }
  }

  async function updateUserInfo(userData) {
    try {
      const response = await userApi.updateUserInfo({
        real_name: userData.real_name,
        email: userData.email,
        phone: userData.phone
      });
      
      if (response.code === 200) {
        // 更新本地存储的用户信息
        if (userInfo.value) {
          userInfo.value.real_name = userData.real_name;
          userInfo.value.email = userData.email;
          userInfo.value.phone = userData.phone;
          
          localStorage.setItem('wms_user_info', JSON.stringify(userInfo.value));
        }
        return true;
      }
      
      // 简化错误信息
      if (response.message && response.message.includes('validation')) {
        throw new Error('请检查输入的字段格式');
      }
      
      throw new Error(response.message || '更新用户信息失败');
    } catch (error) {
      // 简化错误消息
      if (error.message && error.message.includes('validation')) {
        const simpleError = new Error('请检查输入的字段格式');
        throw simpleError;
      }
      
      throw error;
    }
  }
  
  // 更新用户头像
  async function updateAvatar(formData) {
    try {
      const response = await userApi.uploadAvatar(formData);
      
      if (response.code === 200 && response.data) {
        // 获取上传成功后的头像URL
        let avatarUrl = response.data.url;
        
        // 处理头像URL格式
        // 1. 移除/api/v1前缀（如有）
        if (avatarUrl.includes('/api/v1/static/')) {
          avatarUrl = avatarUrl.replace('/api/v1/static/', '/static/');
        }
        
        // 2. 添加时间戳参数，避免缓存问题
        const timestamp = new Date().getTime();
        avatarUrl = avatarUrl.includes('?') 
          ? `${avatarUrl}&t=${timestamp}` 
          : `${avatarUrl}?t=${timestamp}`;
        
        // 3. 确保avatar路径标准化
        const cleanAvatarUrl = processAvatarUrl(avatarUrl);
        
        // 更新用户信息 - 确保头像在所有地方同步更新
        if (userInfo.value) {
          userInfo.value.avatar = cleanAvatarUrl;
          
          // 更新localStorage以确保刷新页面后依然生效
          localStorage.setItem('wms_user_info', JSON.stringify(userInfo.value));
          
          // 派发一个全局事件，通知其他组件头像已更新
          try {
            window.dispatchEvent(new CustomEvent('avatar-updated', { 
              detail: { avatarUrl: cleanAvatarUrl } 
            }));
          } catch (e) {
            console.error('派发头像更新事件失败', e);
          }
        }
        
        // 返回规范化处理后的头像URL
        if (response.data) {
          response.data.processedUrl = cleanAvatarUrl;
        }
      }
      
      return response;
    } catch (error) {
      throw error;
    }
  }
  
  // 清除用户数据
  function clearUserData() {
    token.value = ''
    userInfo.value = {}
    roles.value = []
    localStorage.removeItem('wms_token')
    localStorage.removeItem('wms_user_info')
    localStorage.removeItem('wms_roles')
  }

  // 重置token（供路由守卫使用）
  async function resetToken() {
    clearUserData()
    
    try {
      const permissionStore = usePermissionStore()
      permissionStore.resetRoutes()
    } catch (e) {
      // 静默处理错误
    }
    
    return true
  }

  // 用户列表相关
  const loading = ref(false)
  const userList = ref([])
  const pagination = ref({
    current: 1,
    total: 0,
    pageSize: 10,
    showTotal: true,
    showJumper: true,
    showPageSize: true,
    pageSizeOptions: [10, 20, 50, 100]
  })
  
  // 角色相关
  const roleList = ref([])
  const roleLoading = ref(false)
  
  // 获取角色列表
  async function getRoleList() {
    // 每次调用时强制刷新角色列表，确保显示最新数据
    roleLoading.value = true;
    try {
      // 添加随机参数避免缓存
      const timestamp = new Date().getTime();
      const response = await userApi.getRoleList({_t: timestamp});
      
      // 统一返回值处理，API层可能已经处理过响应，直接返回了数据部分
      let roles = [];
      
      // 如果直接收到角色数组(API已经处理)
      if (Array.isArray(response)) {
        roles = response;
        console.log('API直接返回了角色数组:', roles);
      } 
      // 如果收到标准响应格式
      else if (response && (response.code === 200 || response.code === 0)) {
        // 处理不同结构的返回结果
        if (response.data && Array.isArray(response.data)) {
          // data字段是数组
          roles = response.data;
        } else if (response.data && response.data.list && Array.isArray(response.data.list)) {
          // 包含list的分页结构
          roles = response.data.list;
        } else if (response.data) {
          // 单个角色对象
          roles = [response.data];
        }
      }
      
      console.log('处理前的角色数据:', roles);
      
      // 处理角色对象格式，提取id和name字段
      if (roles && roles.length > 0) {
        // 处理所有角色，但标记管理员角色为禁用状态
        const processedRoles = roles.map(role => {
          // 处理不同的字段命名
          const id = role.id || role.role_id || role.ID || role.Id || 0;
          // 优先使用name字段，不进行修改或改名
          const name = role.name || role.role_name || role.Name || role.RoleName || '员工';
          
          // 判断是否为管理员角色
          const isAdmin = name.toLowerCase().includes('管理员') || 
                         name.toLowerCase().includes('admin') || 
                         name === 'admin' || 
                         id === 1;
          
          return {
            value: id.toString(), // 确保值是字符串类型
            label: name,
            disabled: isAdmin, // 管理员角色设置为禁用
            isAdmin: isAdmin
          };
        });
        
        // 去除重复的角色(基于value)和没有标签的角色
        const uniqueRoles = [];
        const valueSet = new Set();
        
        processedRoles.forEach(role => {
          // 只添加有效的角色选项(必须有标签，且label不是value)
          if (!valueSet.has(role.value) && role.label && role.label !== role.value) {
            valueSet.add(role.value);
            uniqueRoles.push(role);
          }
        });
        
        roleList.value = uniqueRoles;
      }
      
      // 如果没有获取到任何角色，添加默认员工角色
      if (!roleList.value || roleList.value.length === 0) {
        // 设置默认角色 - 只设置员工角色
        roleList.value = [{ value: '2', label: '员工', disabled: false, isAdmin: false }];
      }
      
      console.log('最终处理后的角色列表:', roleList.value);
      return roleList.value;
    } catch (error) {
      console.error('获取角色列表失败:', error);
      
      // 添加默认选项 - 只设置员工角色
      roleList.value = [
        { value: '2', label: '员工', disabled: false, isAdmin: false }
      ];
      
      return roleList.value;
    } finally {
      roleLoading.value = false;
    }
  }
  
  // 获取用户列表
  async function getUserList(params) {
    loading.value = true;
    try {
      // 转换参数以匹配后端API期望的格式
      const apiParams = {
        page: params.current || 1,
        page_size: params.pageSize || 10,
        keyword: params.keyword || ''
      };
      
      if (params.status) {
        apiParams.status = params.status;
      }
      
      const res = await userApi.getUserList(apiParams);
      
      if (res.code === 200 || res.code === 0) {
        const processedData = processUserListData(res.data);
        userList.value = processedData.list || [];
        pagination.value = {
          current: processedData.page || 1,
          total: processedData.total || 0,
          pageSize: processedData.size || 10
        };
        
        // 添加获取用户列表成功的提示消息
        Message.success('获取用户列表成功');
        
      } else {
        Message.error(res.message || '获取用户列表失败');
      }
    } catch (error) {
      console.error('获取用户列表出错:', error);
      Message.error('网络错误，请稍后重试');
    } finally {
      loading.value = false;
    }
  }

  // 创建用户
  async function createUser(userData) {
    try {
      loading.value = true
      
      // 转换参数格式以适应后端API
      const apiData = {
        username: userData.userName,
        password: userData.password || '123456', // 默认密码
        real_name: userData.nickName || '', // 如果没有提供昵称，发送空字符串
        nickname: userData.nickName || '', // 如果没有提供昵称，发送空字符串，不使用用户名作为默认值
        email: userData.email, // 用户必须提供email
        phone: userData.phone, // 用户必须提供phone
        role_id: parseInt(userData.role_id) || 2, // 如果没有选择角色，默认为普通用户(ID=2)
        status: parseInt(userData.status || '1')
      }
      
      const response = await userApi.createUser(apiData)
      
      if (response.code === 200 || response.code === 0) {
        Message.success('创建用户成功')
        return response.data
      }
      
      throw new Error(response.message || '创建失败')
    } catch (error) {
      console.error('创建用户失败:', error)
      Message.error('创建用户失败: ' + (error.message || '未知错误'))
      throw error
    } finally {
      loading.value = false
    }
  }

  // 更新用户
  async function updateUser(id, userData) {
    try {
      loading.value = true
      
      // 转换参数格式以适应后端API
      const apiData = {
        real_name: userData.nickName || '', // 如果没有提供昵称，发送空字符串
        nickname: userData.nickName || '', // 如果没有提供昵称，发送空字符串，不使用用户名作为默认值
        email: userData.email, // 用户必须提供email
        phone: userData.phone, // 用户必须提供phone
        role_id: parseInt(userData.role_id) || 2, // 如果没有选择角色，默认为普通用户(ID=2)
        status: parseInt(userData.status || '1')
      }
      
      const response = await userApi.updateUser(id, apiData)
      
      if (response.code === 200 || response.code === 0) {
        Message.success('更新用户成功')
        return response.data
      }
      
      throw new Error(response.message || '更新失败')
    } catch (error) {
      console.error('更新用户失败:', error)
      Message.error('更新用户失败: ' + (error.message || '未知错误'))
      throw error
    } finally {
      loading.value = false
    }
  }

  // 删除用户
  async function deleteUser(id) {
    try {
      loading.value = true
      
      const response = await userApi.deleteUser(id)
      
      if (response.code === 200 || response.code === 0) {
        Message.success('删除用户成功')
        return true
      }
      
      throw new Error(response.message || '删除失败')
    } catch (error) {
      console.error('删除用户失败:', error)
      Message.error('删除用户失败: ' + (error.message || '未知错误'))
      throw error
    } finally {
      loading.value = false
    }
  }
  
  // 处理用户列表数据
  function processUserListData(data) {
    try {
      if (!data || !Array.isArray(data.list)) {
        return data;
      }
      
      // 处理每个用户数据
      const processedList = data.list.map(user => {
        // 用户名字段适配
        if (!user.userName && user.username) {
          user.userName = user.username;
        }
        
        // 昵称字段适配（完善逻辑，考虑更多可能的字段名）
        if (!user.nickName) {
          user.nickName = user.real_name || user.realName || user.nickname || 
                         user.nick_name || user.name || user.display_name || 
                         user.displayName || user.userName || user.username || '未设置';
        }
        
        // 头像处理
        if (user.avatar) {
          // 确保以/开头
          if (!user.avatar.startsWith('/')) {
            user.avatar = '/' + user.avatar;
          }
          
          // 从baseURL中去除/api/v1部分，得到基础服务器地址
          let serverBaseUrl = baseURL.value;
          if (serverBaseUrl.endsWith('/api/v1')) {
            serverBaseUrl = serverBaseUrl.replace('/api/v1', '');
          }
          
          // 正确拼接服务器地址和头像路径
          const fullUrl = serverBaseUrl + user.avatar;
          
          // 添加时间戳参数避免缓存问题
          const timestamp = new Date().getTime();
          user.avatar = fullUrl + (fullUrl.includes('?') ? '&' : '?') + 't=' + timestamp;
        } else {
          // 默认头像也需要去除/api/v1
          let serverBaseUrl = baseURL.value;
          if (serverBaseUrl.endsWith('/api/v1')) {
            serverBaseUrl = serverBaseUrl.replace('/api/v1', '');
          }
          user.avatar = serverBaseUrl + '/static/system/defaults/avatars/default.jpg?t=' + new Date().getTime();
        }
        
        // 角色字段处理 - 直接使用role_name
        if (user.role_name) {
          user.userType = user.role_name;
        } else if (user.role && user.role.name) {
          user.userType = user.role.name;
        } else if (user.role_id) {
          // 兼容性处理，如果没有role_name但有role_id
          user.userType = user.role_id === 1 ? '系统管理员' : '普通用户';
        }
        
        // 创建时间处理
        if (user.created_at && !user.createTime) {
          user.createTime = user.created_at;
        } else if (user.create_time && !user.createTime) {
          user.createTime = user.create_time;
        } else if (user.createdAt && !user.createTime) {
          user.createTime = user.createdAt;
        } else if (user.createAt && !user.createTime) {
          user.createTime = user.createAt;
        } else if (user.ctime && !user.createTime) {
          user.createTime = user.ctime;
        } else if (user.created && !user.createTime) {
          user.createTime = user.created;
        } else if (!user.createTime) {
          // 如果没有找到任何创建时间字段，查找create_date或create_time等类似字段
          const creationTimeKeys = Object.keys(user).filter(key => 
            key.toLowerCase().includes('creat') && key.toLowerCase().includes('time') ||
            key.toLowerCase().includes('creat') && key.toLowerCase().includes('date')
          );
          
          if (creationTimeKeys.length > 0) {
            // 使用找到的第一个时间字段
            user.createTime = user[creationTimeKeys[0]];
          } else {
            user.createTime = '未知';
          }
        }
        
        // 状态处理
        if (user.status !== undefined && user.status !== null) {
          user.status = String(user.status);
        }
        
        // 手机号和邮箱处理
        user.phone = user.phone || '未设置';
        user.email = user.email || '未设置';
        
        return user;
      });
      
      return {
        ...data,
        list: processedList
      };
    } catch (error) {
      console.error('处理用户列表数据出错:', error);
      return data;
    }
  }

  // 处理头像URL，确保正确格式
  function processAvatarUrl(url) {
    if (!url) return '';
    
    // 去除时间戳参数
    let cleanUrl = url.includes('?') ? url.substring(0, url.indexOf('?')) : url;
    
    // 移除可能存在的/api/v1前缀
    if (cleanUrl.includes('/api/v1')) {
      cleanUrl = cleanUrl.replace('/api/v1', '');
    }
    
    // 确保路径以/开头
    if (cleanUrl && !cleanUrl.startsWith('/')) {
      cleanUrl = '/' + cleanUrl;
    }
    
    return cleanUrl;
  }

  return {
    token,
    userInfo,
    roles,
    isLoggedIn,
    username,
    nickname,
    avatar,
    baseURL,
    loginAction,
    getUserInfo,
    logout,
    updatePassword,
    updateUserInfo,
    updateAvatar,
    clearUserData,
    setUserInfo,
    setToken,
    resetToken,
    
    // 用户管理相关
    loading,
    userList,
    pagination,
    getUserList,
    createUser,
    updateUser,
    deleteUser,
    
    // 角色相关
    roleList,
    roleLoading,
    getRoleList,
    processAvatarUrl,
  }
})